package net.lab1024.sa.gateway.processor;

import lombok.extern.slf4j.Slf4j;
import net.lab1024.sa.gateway.dto.ApiProcessDTO;
import reactor.core.publisher.Mono;

@Slf4j
public abstract class AbstractApiProcessor {
    protected AbstractApiProcessor next;          // 下一个处理器
    protected boolean isMock = false;             // 是否Mock请求
    protected long thresholdTime = 100;           // 超时阈值（ms）

    public void setNextProcessor(AbstractApiProcessor next) {
        this.next = next;
    }

    // 责任链入口：执行当前处理器逻辑，再调用下一个处理器
    public Mono<Void> process(ApiProcessDTO dto) {
        long startTime = System.currentTimeMillis();
        return Mono.defer(() -> doProcess(dto))  // 执行当前处理器逻辑
                .then(Mono.defer(() -> {
                    // 若不是Mock且存在下一个处理器，则继续调用
                    if (!isMock && next != null) {
                        return next.process(dto);
                    }
                    return Mono.empty();
                }))
                .doFinally(signalType -> {
                    // 记录超时日志
                    long spent = System.currentTimeMillis() - startTime;
                    if (spent >= thresholdTime) {
                        log.warn("Processor [{}] slow! Cost: {}ms",
                                this.getClass().getSimpleName(), spent);
                    }
                });
    }

    // 抽象方法：子类实现具体逻辑
    protected abstract Mono<Void> doProcess(ApiProcessDTO dto);
}